#include <iostream>
#include <map>

using namespace std;

const int MAXSIZE = 90000;

struct State
{
    // длина длиннейшей строки,
    // соответствующей данному состоянию
	int len;
	// суффиксная ссылка ведёт в такое состояние,
	// которому соответствует наидлиннейший суффикс строки,
	// находящийся в другом классе - endpos-эквивалентности
	int link;
	// число путей
	// достижимых из данного состояния
	int numberOfPaths;
	// состояния достижимые из данного
	// ключ - символ, соответствующий ребру, ведущему в состояние
	// значение - номер состояния в массиве states
	map<char,int> nextStates;
};


State states[MAXSIZE*2];
int sz;
int last; // состояние, соответствующее всей строке на данный момент
// результат функции поиска k-ой подстроки
string result = "";

// инициализация суффиксного автомата
void initSuffixAutomaton()
{
	sz = last = 0;
	states[0].len = 0;
	states[0].link = -1;
	++sz;
}

// добавление символа в суффиксный автомат
void addSuffixAutomaton(char symbol)
{
    // создаем новое состояние current
    // которое в конце станет last
	int current = sz++;
	// ясно, что длина длиннейшей строки
	// ему соответствующей будет на 1 больше
	// длиннейшей строки, соответствующей предыдущему
	// последнему состоянию
	states[current].len = states[last].len + 1;

	int p;
    // cделаем цикл: изначально мы стоим в last;
    // если из него нет перехода по symbol,
    // то добавляем этот переход по symbol в состояние cur,
    // затем переходим по суффиксной ссылке, снова проверяя — если нет перехода, то добавляем.
    // Если в какой-то момент случится, что такой переход уже есть,
    // то остановимся и p будет номером состояния, на котором это произошло
	for (p = last; p != -1 && !states[p].nextStates.count(symbol); p = states[p].link)
    {
        states[p].nextStates[symbol] = current;
    }
    // если ни разу не случилось, что переход по symbol уже имелся
    // и мы так и дошли до фиктивного состояния -1,
    // то присваиваем суффиксной ссылке из нового
    // состояния значение 0 и выходим
	if (p == -1)
    {
		states[current].link = 0;
    }
	else
    {
        // иначе мы остановились в состоянии p
        // из которого есть переход по symbol
        // обозначим q состояние, куда ведет этот переход
		int q = states[p].nextStates[symbol];
		// если выполняется условие ниже, то все понятно
		if (states[p].len + 1 == states[q].len)
        {
            states[current].link = q;
        }
		else
        {
            // в противном случае необходимо произвести "клонирование" состояния q:
            // создать новое состояние clone, скопировав в него все данные из вершины q
            // только len надо присвоить: len(clone) = len(p) + 1
			int clone = sz++;
			states[clone].len = states[p].len + 1;
			states[clone].nextStates = states[q].nextStates;
            // после клонирования проводим суффиксную ссылку
            // из current в clone и перенаправляем суффиксную ссылку из q в clone
			states[clone].link = states[q].link;
            states[q].link = states[current].link = clone;
            // в конце проходим от состояния p по суффиксным ссылкам,
            // и для каждого очередного состояния проверяем:
            // если имелся переход по symbol в состояние q,
            // то перенаправляем его в состояние clone (если нет, то останавливаемся)
			for (; p != -1 && states[p].nextStates[symbol] == q; p = states[p].link)
            {
                states[p].nextStates[symbol] = clone;
            }
		}
	}
	last = current;
}

// вычисляет для каждого состояния суффиксного автомата
// количество различных путей, достижимых из вершины index
int computePaths(int index)
{
    int i = 0;
    if (index == last) return 1;
    for (map<char, int>::iterator it =  states[index].nextStates.begin();
                                  it != states[index].nextStates.end(); ++it, ++i)
    {
        states[index].numberOfPaths += computePaths((*it).second);
    }
    return ++states[index].numberOfPaths;
}

// нахождение лексикографически i-й строки
// достижимой из вершины с индексом index
void findKthSubstring(int k, int index)
{
    int a = k - 1;

    if (states[index].numberOfPaths < a)
    {
        return;
    }

    map<char, int>::iterator it = states[index].nextStates.begin();

    a -= states[(*it++).second].numberOfPaths;

    while (a > 0 && it != states[index].nextStates.end())
    {
        a -= states[(*it++).second].numberOfPaths;
    }

    --it;

    a += states[(*it).second].numberOfPaths;
    result += (*it).first;

    if (a == 0)
    {
        return;
    }

    findKthSubstring(a, (*(it)).second);
}

int main()
{
    string str;
    int q, k;
    initSuffixAutomaton();

    cin >> str;

    // строим суффиксный автомат для данной строки
    for (int i = 0; i < str.length(); ++i)
    {
        addSuffixAutomaton(str[i]);
    }

    // вычисляем числа достижимых из каждого состояния путей
    computePaths(0);

    cin >> q;

    for (int i = 0; i < q; ++i)
    {
        result = "";
        cin >> k;
        // находим лексикографически k-ю подстроку
        findKthSubstring(k, 0);
        cout << result << endl;
    }

    return 0;
}
